package BehaviorPattern.State;

/**
 * @author: Themberfue
 * @date: 2025/8/13 11:35
 * @description:
 */
// 1. 环境类：订单
class Order {
    // 定义所有可能的状态
    public static final State NEW = new NewState();
    public static final State PAID = new PaidState();
    public static final State SHIPPED = new ShippedState();
    public static final State DELIVERED = new DeliveredState();
    public static final State CANCELLED = new CancelledState();

    private String orderId;
    private State currentState; // 当前状态

    public Order(String orderId) {
        this.orderId = orderId;
        this.currentState = NEW; // 初始状态为新订单
        System.out.println("创建订单: " + orderId + "，当前状态: " + currentState.getName());
    }

    // 设置当前状态
    public void setState(State state) {
        this.currentState = state;
        System.out.println("订单 " + orderId + " 状态变更为: " + currentState.getName());
    }

    // 获取当前状态名称
    public String getCurrentStateName() {
        return currentState.getName();
    }

    // 订单操作（委托给当前状态处理）
    public void pay() {
        currentState.pay(this);
    }

    public void ship() {
        currentState.ship(this);
    }

    public void deliver() {
        currentState.deliver(this);
    }

    public void cancel() {
        currentState.cancel(this);
    }
}

// 2. 抽象状态：订单状态
interface State {
    String getName();
    void pay(Order order);    // 支付
    void ship(Order order);   // 发货
    void deliver(Order order); // 送达
    void cancel(Order order);  // 取消
}

// 3. 具体状态：新订单（未支付）
class NewState implements State {
    @Override
    public String getName() {
        return "新订单";
    }

    @Override
    public void pay(Order order) {
        // 新订单可以支付，支付后转为已支付状态
        System.out.println("订单支付成功");
        order.setState(Order.PAID);
    }

    @Override
    public void ship(Order order) {
        System.out.println("错误：未支付的订单不能发货");
    }

    @Override
    public void deliver(Order order) {
        System.out.println("错误：未支付的订单不能送达");
    }

    @Override
    public void cancel(Order order) {
        // 新订单可以取消
        System.out.println("订单取消成功");
        order.setState(Order.CANCELLED);
    }
}

// 3. 具体状态：已支付
class PaidState implements State {
    @Override
    public String getName() {
        return "已支付";
    }

    @Override
    public void pay(Order order) {
        System.out.println("错误：订单已支付，不能重复支付");
    }

    @Override
    public void ship(Order order) {
        // 已支付订单可以发货，发货后转为已发货状态
        System.out.println("订单发货成功");
        order.setState(Order.SHIPPED);
    }

    @Override
    public void deliver(Order order) {
        System.out.println("错误：未发货的订单不能送达");
    }

    @Override
    public void cancel(Order order) {
        System.out.println("订单取消成功，已发起退款");
        order.setState(Order.CANCELLED);
    }
}

// 3. 具体状态：已发货
class ShippedState implements State {
    @Override
    public String getName() {
        return "已发货";
    }

    @Override
    public void pay(Order order) {
        System.out.println("错误：订单已支付，不能重复支付");
    }

    @Override
    public void ship(Order order) {
        System.out.println("错误：订单已发货，不能重复发货");
    }

    @Override
    public void deliver(Order order) {
        // 已发货订单可以送达，送达后转为已送达状态
        System.out.println("订单送达成功");
        order.setState(Order.DELIVERED);
    }

    @Override
    public void cancel(Order order) {
        System.out.println("错误：已发货的订单不能取消，请申请退货");
    }
}

// 3. 具体状态：已送达
class DeliveredState implements State {
    @Override
    public String getName() {
        return "已送达";
    }

    @Override
    public void pay(Order order) {
        System.out.println("错误：订单已支付，不能重复支付");
    }

    @Override
    public void ship(Order order) {
        System.out.println("错误：订单已送达，不能再次发货");
    }

    @Override
    public void deliver(Order order) {
        System.out.println("错误：订单已送达，不能重复送达");
    }

    @Override
    public void cancel(Order order) {
        System.out.println("错误：已送达的订单不能取消，请申请退货");
    }
}

// 3. 具体状态：已取消
class CancelledState implements State {
    @Override
    public String getName() {
        return "已取消";
    }

    @Override
    public void pay(Order order) {
        System.out.println("错误：已取消的订单不能支付");
    }

    @Override
    public void ship(Order order) {
        System.out.println("错误：已取消的订单不能发货");
    }

    @Override
    public void deliver(Order order) {
        System.out.println("错误：已取消的订单不能送达");
    }

    @Override
    public void cancel(Order order) {
        System.out.println("错误：订单已取消，不能重复取消");
    }
}

// 4. 客户端代码
public class StateExample {
    public static void main(String[] args) {
        // 创建订单（初始状态为新订单）
        Order order = new Order("ORD-20230501-001");

        // 测试订单状态流转
        System.out.println("\n=== 正常流程 ===");
        order.pay();    // 支付
        order.ship();   // 发货
        order.deliver();// 送达
        order.cancel(); // 尝试取消（应该失败）

        // 测试另一个订单的异常流程
        System.out.println("\n=== 异常流程 ===");
        Order order2 = new Order("ORD-20230501-002");
        order2.ship();  // 未支付尝试发货（失败）
        order2.cancel();// 取消订单
        order2.pay();   // 已取消尝试支付（失败）
    }
}

